/**
 * Trabajo de Ingeniería de Software 2
 * Año 2008
 * Sistema de Reserva de Recursos.
 * Desarrolladores: - Marcelo Ferreira.
 *                  - Christian Gómez.
 *                  - Marcelo Rodas.
 */
package controller;

import java.util.List;
import java.util.Map;
import javax.annotation.Resource;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.model.SelectItem;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.PersistenceUnit;
import javax.persistence.Query;
import javax.faces.application.FacesMessage;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import javax.faces.FacesException;
import java.util.HashMap;
import javax.faces.validator.ValidatorException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import javax.servlet.http.HttpSession;
import javax.transaction.UserTransaction;
import modelo.Permiso;
import modelo.Permisorol;
import modelo.Usuario;

/**
 * Controlador de las Funcionalidades de Permiso.
 * Utilizado para manejar la capa de controlador (MVC)
 * del sistema.
 * @author cgomez
 * @version 1.0
 */
public class PermisoController {

    // POJO de Permiso Representada.
    private Permiso permiso = null;
    // Lista de Permiso
    private List<Permiso> permisos = null;
    // Transacción del usuario.
    @Resource
    private UserTransaction utx = null;
    // Administrador de la Persistencia de los Permiso.
    // Relaciona al Controlador con el Modelo (MVC)
    @PersistenceUnit(unitName = "sistemaReservaPU")
    private EntityManagerFactory emf = null;
    //varieble que contiene el objeto usuario de la sesion
    Usuario user;
    //Variable que contiene el nombre de usuario de la sesion actual
    private String nombre;
    //Variable que contiene el apellido del usuario de la sesion actual
    private String apellido;

    /**
     * Constructor de la Clase
     */
    public PermisoController() {
        HttpSession session = (HttpSession) FacesContext.getCurrentInstance().getExternalContext().getSession(false);
        user = (Usuario) session.getAttribute("user");
        nombre = user.getIddatospersonales().getNombres();
        apellido = user.getIddatospersonales().getApellidos();
    }

    /**
     * Getter del Administrador de Entidades.
     * @return EntityManager
     */
    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }
    // ---------- Variables para paginar en el jsp -------------
    // variable auxiliar que indica el tamaño de conjunto
    public int batchSize = 100;
    // variable auxiliar para indicar el 1er elemento
    private int firstItem = 0;
    // variable auxiliar utilizado como contador de elementos
    private int itemCount = -1;

    /**
     * Setter del Usuario de los Permisorol
     * @param permisorolCollection coleccion de usuarios
     */
    public void setPermisorolCollectionOfPermiso(Permisorol[] permisorolCollection) {
        List<Permisorol> permisorolCollectionList = Arrays.asList(permisorolCollection);
        permiso.setPermisorolCollection(permisorolCollectionList);
    }

    /**
     * Getter del Usuario de los Permisorol
     * @return colleccion de Permisorol
     */
    public Permisorol[] getPermisorolCollectionOfPermiso() {
        Collection<Permisorol> permisorolCollection = permiso.getPermisorolCollection();
        if (permisorolCollection == null) {
            return new Permisorol[0];
        }
        return permisorolCollection.toArray(new Permisorol[0]);
    }

    /**
     * Metodo para obtener una lista de los Permisos disponibles de varias selecciones
     * @return lista de Permiso
     */
    public SelectItem[] getPermisosAvailableSelectMany() {
        return getPermisosAvailable(false);
    }

    /**
     * Metodo publico para obtener una lista de los Permiso disponibles de una sola seleccion
     * @return lista de Permiso
     */
    public SelectItem[] getPermisosAvailableSelectOne() {
        return getPermisosAvailable(true);
    }

    /**
     * Metodo privado para obtener una lista de los Permiso disponibles de una sola seleccion
     * @return lista de Permiso
     */
    private SelectItem[] getPermisosAvailable(boolean one) {
        List<Permiso> allPermisos = getPermisos(true);
        int size = one ? allPermisos.size() + 1 : allPermisos.size();
        SelectItem[] items = new SelectItem[size];
        int i = 0;
        if (one) {
            items[0] = new SelectItem("", "---");
            i++;
        }
        for (Permiso x : allPermisos) {
            items[i++] = new SelectItem(x, x.getDescripcionMenu());
        }
        return items;
    }

    /**
     * Metodo para obtener el objeto Permiso del Request
     * @return el objeto Permiso obtenido
     */
    public Permiso getPermiso() {
        if (permiso == null) {
            permiso = getPermisoFromRequest();
        }
        if (permiso == null) {
            permiso = new Permiso();
        }
        return permiso;
    }

    /**
     * Metodo para resetear los valores de inicio y llamar al Tag de Lista de Permiso
     * @return el tag de la Lista de Permiso
     */
    public String listSetup() {
        reset(true);
        return "permiso_list";
    }

    /**
     * Metodo para inicializar los valores del Objeto Permiso para un nuevo objeto
     * @return el Tag del JSP para crear una nueva entrada de Permiso
     */
    public String createSetup() {
        reset(false);
        permiso = new Permiso();
        return "permiso_create";
    }

    /**
     * Metodo publico para crear una nueva entrada de Permiso
     * @return el Tag del siguiente JSP a desplegar
     */
    public String create() {
        if (permiso.getPermisorolCollection() == null) {
            permiso.setPermisorolCollection(new ArrayList<Permisorol>());
        }
        EntityManager em = getEntityManager();
        try {
            utx.begin();
            List<Permisorol> attachedPermisorolCollection = new ArrayList<Permisorol>();
            for (Permisorol permisorolCollectionPermisorolToAttach : permiso.getPermisorolCollection()) {
                permisorolCollectionPermisorolToAttach = em.getReference(permisorolCollectionPermisorolToAttach.getClass(), permisorolCollectionPermisorolToAttach.getPermisorolPK());
                attachedPermisorolCollection.add(permisorolCollectionPermisorolToAttach);
            }
            permiso.setPermisorolCollection(attachedPermisorolCollection);
            em.persist(permiso);
            for (Permisorol permisorolCollectionPermisorol : permiso.getPermisorolCollection()) {
                Permiso oldPermisoOfPermisorolCollectionPermisorol = permisorolCollectionPermisorol.getPermiso();
                permisorolCollectionPermisorol.setPermiso(permiso);
                permisorolCollectionPermisorol = em.merge(permisorolCollectionPermisorol);
                if (oldPermisoOfPermisorolCollectionPermisorol != null) {
                    oldPermisoOfPermisorolCollectionPermisorol.getPermisorolCollection().remove(permisorolCollectionPermisorol);
                    oldPermisoOfPermisorolCollectionPermisorol = em.merge(oldPermisoOfPermisorolCollectionPermisorol);
                }
            }
            utx.commit();
            addSuccessMessage("El permiso fue creado exitosamente.");
        } catch (Exception ex) {
            try {
                if (findPermiso(permiso.getIdPermiso()) != null) {
                    addErrorMessage("El permiso " + permiso + " ya existe.");
                } else {
                    ensureAddErrorMessage(ex, "A persistence error occurred.");
                }
                utx.rollback();
            } catch (Exception e) {
                ensureAddErrorMessage(e, "An error occurred attempting to roll back the transaction.");
            }
            return null;
        } finally {
            em.close();
        }
        return listSetup();
    }

    /**
     * Funcion de Navegacion a la Pagina Detail.jsp de los Objetos Permiso
     * @return String
     */
    public String detailSetup() {
        return scalarSetup("permiso_detail");
    }

    /**
     * Funcion de Navegacion a la Pagina DetailS.jsp de los Permiso
     * @return String
     */
    public String editSetup() {
        return scalarSetup("permiso_edit");
    }

    /*
     * Función de Navegación General, controla si existe la ruta de
     * navegación.
     */
    private String scalarSetup(String destination) {
        reset(false);
        permiso = getPermisoFromRequest();
        if (permiso == null) {
            String requestPermisoString = getRequestParameter("jsfcrud.currentPermiso");
            addErrorMessage("El permiso con el id " + requestPermisoString + " ya no existe.");
            String relatedControllerOutcome = relatedControllerOutcome();
            if (relatedControllerOutcome != null) {
                return relatedControllerOutcome;
            }
            return listSetup();
        }
        return destination;
    }

    /*
     * Función de Navegación General, controla si existe la ruta de
     * navegación. Viene desde una pagina diferente y sirve para controlar
     * los reset de otros objetos
     */
    private String scalarSetup2() {
        reset(false);
        permiso = getPermisoFromRequest();
        if (permiso == null) {
            String requestPermisoString = getRequestParameter("jsfcrud.currentPermiso");
            addErrorMessage("El permiso con el id " + requestPermisoString + " ya no existe.");
            String relatedControllerOutcome = relatedControllerOutcome();
            if (relatedControllerOutcome != null) {
                return relatedControllerOutcome;
            }
            return "app-main";
        }
        HttpSession session = (HttpSession) FacesContext.getCurrentInstance().getExternalContext().getSession(false);
        try {
            if (permiso.getTagMenu().equals("solicitudusuario_listSolicitudesPendientesAprobador")) {
                SolicitudusuarioController controlador = (SolicitudusuarioController) session.getAttribute("solicitudusuario_listSolicitudesPendientesAprobador");
                controlador.reset(true);
            } else if (permiso.getTagMenu().equals("ListSolicitudesPendientes")) {
                SolicitudreservaController controlador = (SolicitudreservaController) session.getAttribute("ListSolicitudesPendientes");
                controlador.reset(true);
            } else if (permiso.getTagMenu().equals("reserva_list")) {
                ReservaController controlador = (ReservaController) session.getAttribute("reserva_list");
                controlador.reset(true);
                controlador.setReservas(controlador.getReservas(false));
            } else if (permiso.getTagMenu().equals("usoreiro_list")) {
                UsoretiroController controlador = (UsoretiroController) session.getAttribute("reserva_list");
                controlador.reset(true);
            }

        } catch (Exception e) {
            ;
        }
        return permiso.getTagMenu();
    }

    /**
     * Función publica que procesa los cambios realizados sobre los
     * Permiso's Representados.
     * @return String
     */
    public String edit() {
        PermisoConverter converter = new PermisoConverter();
        String permisoString = converter.getAsString(FacesContext.getCurrentInstance(), null, permiso);
        String currentPermisoString = getRequestParameter("jsfcrud.currentPermiso");
        if (permisoString == null || permisoString.length() == 0 || !permisoString.equals(currentPermisoString)) {
            String outcome = editSetup();
            if ("permiso_edit".equals(outcome)) {
                addErrorMessage("No se pudo editar el permiso. Intente nuevamente.");
            }
            return outcome;
        }
        EntityManager em = getEntityManager();
        try {
            utx.begin();
            Permiso persistentPermiso = em.find(Permiso.class, permiso.getIdPermiso());
            Collection<Permisorol> permisorolCollectionOld = persistentPermiso.getPermisorolCollection();
            Collection<Permisorol> permisorolCollectionNew = permiso.getPermisorolCollection();
            List<Permisorol> attachedPermisorolCollectionNew = new ArrayList<Permisorol>();
            for (Permisorol permisorolCollectionNewPermisorolToAttach : permisorolCollectionNew) {
                permisorolCollectionNewPermisorolToAttach = em.getReference(permisorolCollectionNewPermisorolToAttach.getClass(), permisorolCollectionNewPermisorolToAttach.getPermisorolPK());
                attachedPermisorolCollectionNew.add(permisorolCollectionNewPermisorolToAttach);
            }
            permisorolCollectionNew = attachedPermisorolCollectionNew;
            permiso.setPermisorolCollection(permisorolCollectionNew);
            permiso = em.merge(permiso);
            for (Permisorol permisorolCollectionOldPermisorol : permisorolCollectionOld) {
                if (!permisorolCollectionNew.contains(permisorolCollectionOldPermisorol)) {
                    permisorolCollectionOldPermisorol.setPermiso(null);
                    permisorolCollectionOldPermisorol = em.merge(permisorolCollectionOldPermisorol);
                }
            }
            for (Permisorol permisorolCollectionNewPermisorol : permisorolCollectionNew) {
                if (!permisorolCollectionOld.contains(permisorolCollectionNewPermisorol)) {
                    Permiso oldPermisoOfPermisorolCollectionNewPermisorol = permisorolCollectionNewPermisorol.getPermiso();
                    permisorolCollectionNewPermisorol.setPermiso(permiso);
                    permisorolCollectionNewPermisorol = em.merge(permisorolCollectionNewPermisorol);
                    if (oldPermisoOfPermisorolCollectionNewPermisorol != null && !oldPermisoOfPermisorolCollectionNewPermisorol.equals(permiso)) {
                        oldPermisoOfPermisorolCollectionNewPermisorol.getPermisorolCollection().remove(permisorolCollectionNewPermisorol);
                        oldPermisoOfPermisorolCollectionNewPermisorol = em.merge(oldPermisoOfPermisorolCollectionNewPermisorol);
                    }
                }
            }
            utx.commit();
            addSuccessMessage("El permiso fue actualizado exitosamente.");
        } catch (Exception ex) {
            try {
                String msg = ex.getLocalizedMessage();
                if (msg != null && msg.length() > 0) {
                    addErrorMessage(msg);
                } else if (getPermisoFromRequest() == null) {
                    addErrorMessage("El permiso con el id " + currentPermisoString + " ya no existe.");
                    utx.rollback();
                    return listSetup();
                } else {
                    addErrorMessage("A persistence error occurred.");
                }
                utx.rollback();
            } catch (Exception e) {
                ensureAddErrorMessage(e, "An error occurred attempting to roll back the transaction.");
            }
            return null;
        } finally {
            em.close();
        }
        return detailSetup();
    }

    /**
     * Funcion que permite la eliminacion de una entrada de Permiso
     * @return String
     */
    public String destroy() {
        permiso = getPermisoFromRequest();
        if (permiso == null) {
            String currentPermisoString = getRequestParameter("jsfcrud.currentPermiso");
            addErrorMessage("El permiso con el id " + currentPermisoString + " ya no existe.");
            String relatedControllerOutcome = relatedControllerOutcome();
            if (relatedControllerOutcome != null) {
                return relatedControllerOutcome;
            }
            return listSetup();
        }
        EntityManager em = getEntityManager();
        try {
            utx.begin();
            permiso = em.getReference(permiso.getClass(), permiso.getIdPermiso());
            Collection<Permisorol> permisorolCollection = permiso.getPermisorolCollection();
            for (Permisorol permisorolCollectionPermisorol : permisorolCollection) {
                permisorolCollectionPermisorol.setPermiso(null);
                permisorolCollectionPermisorol = em.merge(permisorolCollectionPermisorol);
            }
            em.remove(permiso);
            utx.commit();
            addSuccessMessage("El permiso fue borrado con éxito.");
        } catch (Exception ex) {
            try {
                ensureAddErrorMessage(ex, "A persistence error occurred.");
                utx.rollback();
            } catch (Exception e) {
                ensureAddErrorMessage(e, "An error occurred attempting to roll back the transaction.");
            }
            return null;
        } finally {
            em.close();
        }
        String relatedControllerOutcome = relatedControllerOutcome();
        if (relatedControllerOutcome != null) {
            return relatedControllerOutcome;
        }
        return listSetup();
    }

    /**
     * Función privada para obtener el Objeto Permiso del Request.
     * @return Permiso
     */
    private Permiso getPermisoFromRequest() {
        String theId = getRequestParameter("jsfcrud.currentPermiso");
        return (Permiso) new PermisoConverter().getAsObject(FacesContext.getCurrentInstance(), null, theId);
    }

    /**
     * Función para obtener un valor del request.
     * @param key
     * @return String
     */
    private String getRequestParameter(String key) {
        return FacesContext.getCurrentInstance().getExternalContext().getRequestParameterMap().get(key);
    }

    /**
     * Getter de Permiso (atributo local).
     * @return List<Permiso>
     */
    public List<Permiso> getPermisos() {
        if (permisos == null) {
            permisos = getPermisos(false);
        }
        return permisos;
    }

    /**
     * Getter de todos los Permiso (de la Base de Datos)
     * @param all
     * @return List<Permiso>
     */
    public List<Permiso> getPermisos(boolean all) {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select object(o) from Permiso as o");
            if (!all) {
                q.setMaxResults(batchSize);
                q.setFirstResult(getFirstItem());
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    /*
     *-------------------------------------------------------------------
     * Funciones de manejo de Mensajes y Errores.
     *-------------------------------------------------------------------
     */
    
    /**
     * Asegura que se almacenen los errores
     * @param ex
     * @param defaultMsg
     */
    private void ensureAddErrorMessage(Exception ex, String defaultMsg) {
        String msg = ex.getLocalizedMessage();
        if (msg != null && msg.length() > 0) {
            addErrorMessage(msg);
        } else {
            addErrorMessage(defaultMsg);
        }
    }

    /**
     * Agrega mensajes de Error para la Página.
     * @param msg
     */
    public static void addErrorMessage(String msg) {
        FacesMessage facesMsg = new FacesMessage(FacesMessage.SEVERITY_ERROR, msg, msg);
        FacesContext.getCurrentInstance().addMessage(null, facesMsg);
    }

    /**
     * Agrega mensajes de Exito para la Página.
     * @param msg
     */
    public static void addSuccessMessage(String msg) {
        FacesMessage facesMsg = new FacesMessage(FacesMessage.SEVERITY_INFO, msg, msg);
        FacesContext.getCurrentInstance().addMessage("successInfo", facesMsg);
    }

    /**
     * Obtiene un Objeto Permiso con el id correspondiente.
     * @param id idPermiso
     * @return o Objeto Permiso
     */
    public Permiso findPermiso(Integer id) {
        EntityManager em = getEntityManager();
        try {
            Permiso o = (Permiso) em.find(Permiso.class, id);
            return o;
        } finally {
            em.close();
        }
    }

    /**
     * ------------------------------------------
     * Funciones de Iteración
     * ------------------------------------------
     */
    
    /**
     * Funcion para obtener una cuenta de todos los items de esta clase
     * @return int
     */    
    public int getItemCount() {
        if (itemCount == -1) {
            EntityManager em = getEntityManager();
            try {
                itemCount = ((Long) em.createQuery("select count(o) from Permiso as o").getSingleResult()).intValue();
            } finally {
                em.close();
            }
        }
        return itemCount;
    }
    
    /**
     * Funcion para obtener el primer item de esta clase
     * @return int
     */
    public int getFirstItem() {
        getItemCount();
        if (firstItem >= itemCount) {
            if (itemCount == 0) {
                firstItem = 0;
            } else {
                int zeroBasedItemCount = itemCount - 1;
                double pageDouble = zeroBasedItemCount / batchSize;
                int page = (int) Math.floor(pageDouble);
                firstItem = page * batchSize;
            }
        }
        return firstItem;
    }
    
    /**
     * Funcion para obtener el ultimo item de esta clase
     * @return int
     */
    public int getLastItem() {
        getFirstItem();
        return firstItem + batchSize > itemCount ? itemCount : firstItem + batchSize;
    }
    
    /**
     * Funcion para obtener el tamaño de datos a desplegar de esta clase
     * @return int
     */
    public int getBatchSize() {
        return batchSize;
    }
    
    /**
     * Funcion para obtener el siguiente item de esta clase
     * @return int
     */
    public String next() {
        reset(false);
        getFirstItem();
        if (firstItem + batchSize < itemCount) {
            firstItem += batchSize;
        }
        return "permiso_list";
    }
    
    /**
     * Funcion para obtener el item anterior de esta clase
     * @return int
     */
    public String prev() {
        reset(false);
        getFirstItem();
        firstItem -= batchSize;
        if (firstItem < 0) {
            firstItem = 0;
        }
        return "permiso_list";
    }
    
    /**
     * Funcion para saber de que contexto esta viniendo la peticion
     * @return String
     */
    private String relatedControllerOutcome() {
        String relatedControllerString = getRequestParameter("jsfcrud.relatedController");
        String relatedControllerTypeString = getRequestParameter("jsfcrud.relatedControllerType");
        if (relatedControllerString != null && relatedControllerTypeString != null) {
            FacesContext context = FacesContext.getCurrentInstance();
            Object relatedController = context.getApplication().getELResolver().getValue(context.getELContext(), null, relatedControllerString);
            try {
                Class<?> relatedControllerType = Class.forName(relatedControllerTypeString);
                Method detailSetupMethod = relatedControllerType.getMethod("detailSetup");
                return (String) detailSetupMethod.invoke(relatedController);
            } catch (ClassNotFoundException e) {
                throw new FacesException(e);
            } catch (NoSuchMethodException e) {
                throw new FacesException(e);
            } catch (IllegalAccessException e) {
                throw new FacesException(e);
            } catch (InvocationTargetException e) {
                throw new FacesException(e);
            }
        }
        return null;
    }

    /**
     * Borra la referencia al objeto Representado (Borrado sin persistencia).
     * @param resetFirstItem
     */
    private void reset(boolean resetFirstItem) {
        permiso = null;
        permisos = null;
        itemCount = -1;
        if (resetFirstItem) {
            firstItem = 0;
        }
    }
    private Map<Object, String> asString = null;
    
    /**
     * Mapea el tipo de Objeto a un tipo String
     * @return Map<Object, String>
     */
    public Map<Object, String> getAsString() {
        if (asString == null) {
            asString = new HashMap<Object, String>() {

                @Override
                public String get(Object key) {
                    if (key instanceof Object[]) {
                        Object[] keyAsArray = (Object[]) key;
                        if (keyAsArray.length == 0) {
                            return "(No Items)";
                        }
                        StringBuffer sb = new StringBuffer();
                        for (int i = 0; i < keyAsArray.length; i++) {
                            if (i > 0) {
                                sb.append("<br />");
                            }
                            sb.append(keyAsArray[i]);
                        }
                        return sb.toString();
                    }
                    return new PermisoConverter().getAsString(FacesContext.getCurrentInstance(), null, (Permiso) key);
                }
            };
        }
        return asString;
    }

    /**
     * Función que Vincula y Valida JSP con el Objeto Permiso Representado.
     * @param facesContext
     * @param component
     * @param value
     */
    public void validateCreate(FacesContext facesContext, UIComponent component, Object value) {
        PermisoConverter converter = new PermisoConverter();
        String newPermisoString = converter.getAsString(FacesContext.getCurrentInstance(), null, new Permiso());
        String permisoString = converter.getAsString(FacesContext.getCurrentInstance(), null, permiso);
        if (!newPermisoString.equals(permisoString)) {
            createSetup();
        }
    }

    /**
     * Metodo que devuelve el tag para los detalles de Permiso, desde otra pagina
     * @return String
     */
    public String detailSetup2() {
        return scalarSetup2();
    }

    /**
     * Metodo que devuelve una lista de Permisos
     * @return Objeto Permiso
     */
    public List<Permiso> getPermisos2() {
        if (permisos == null) {
            permisos = getPermisos2(false);
        }
        return permisos;
    }

    /**
     * Metodo que devuelve una lista de Permisos
     * @param all
     * @return Objeto Permiso
     */
    public List<Permiso> getPermisos2(boolean all) {
        EntityManager em = getEntityManager();
        /*HttpSession session = (HttpSession)
        FacesContext.getCurrentInstance().getExternalContext().getSession(false);
        Usuario user = (Usuario) session.getAttribute("user");
         */

        String sql = "select p from Permiso p where p.idPermiso in" +
                "(SELECT pr.permisorolPK.idPermiso FROM Permisorol pr WHERE pr.permisorolPK.idRol = '" +
                user.getIdRol().getIdRol() + "') order by p.descripcionMenu";

        try {
            Query q = em.createQuery(sql);
            if (!all) {
                q.setMaxResults(30);//El parametro restringe el numero de menus que puede aparecer en la lista

                q.setFirstResult(getFirstItem());
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    /**
     * Metodo que obtiene el apellido del usuario de la sesion
     * @return String
     */
    public String getApellido() {
        return apellido;
    }

    /**
     * Metodo que fija el apellido del usuario de la sesion
     * @param apellido
     */
    public void setApellido(String apellido) {
        this.apellido = apellido;
    }

    /**
     * Metodo que obtiene el nombredel usuario de la sesion
     * @return String
     */
    public String getNombre() {
        return nombre;
    }

    /**
     * Metodo que fija el nombre del usuario de la sesion
     * @param nombre
     */
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
}
